{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Supervised Repertoire Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While solving a sequence classification can be useful in the cases where the label applies to every sequence in a sample (such as in tetramer-sorted T-cells), there are times where the label may truly only apply to a set of sequences. For example, in the case where one may sequence tumor-infiltrating lymphocytes (TIL) and  there is a label at the repertoire/sample level such as which therapy the sample received. In this case, there may be a structural signature within a set of sequences that is predictive but not every single sequence has that signature. This is a case where we want to learn what is the structural signature buried in a set of sequenes and which sequences carry this signature."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To demo this utility of a repertoire/sample level classifier, we will first upload dat from the Rudqvist dataseet. In this dataset, 20 mice with implanted tumors were treated with 4 modes of therapy (Control, 9H10, RT, or Combo). We want to know whether the TCRrepertoire from their tumors is predictive of the therapy they received."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loading Data...\n",
      "Embedding Sequences...\n",
      "Data Loaded\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Process ForkPoolWorker-16:\n",
      "Process ForkPoolWorker-3:\n",
      "Process ForkPoolWorker-33:\n",
      "Process ForkPoolWorker-17:\n",
      "Process ForkPoolWorker-23:\n",
      "Process ForkPoolWorker-18:\n",
      "Process ForkPoolWorker-9:\n",
      "Process ForkPoolWorker-36:\n",
      "Process ForkPoolWorker-32:\n",
      "Process ForkPoolWorker-39:\n",
      "Process ForkPoolWorker-10:\n",
      "Process ForkPoolWorker-15:\n",
      "Process ForkPoolWorker-27:\n",
      "Process ForkPoolWorker-5:\n",
      "Process ForkPoolWorker-20:\n",
      "Process ForkPoolWorker-14:\n",
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-6:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-12:\n",
      "Process ForkPoolWorker-37:\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-29:\n",
      "Traceback (most recent call last):\n",
      "Process ForkPoolWorker-2:\n",
      "Process ForkPoolWorker-35:\n",
      "Process ForkPoolWorker-26:\n",
      "Process ForkPoolWorker-21:\n",
      "Process ForkPoolWorker-31:\n",
      "Process ForkPoolWorker-38:\n",
      "Process ForkPoolWorker-40:\n",
      "Process ForkPoolWorker-30:\n",
      "Process ForkPoolWorker-7:\n",
      "Process ForkPoolWorker-11:\n",
      "Process ForkPoolWorker-28:\n",
      "Process ForkPoolWorker-19:\n",
      "Process ForkPoolWorker-24:\n",
      "Process ForkPoolWorker-22:\n",
      "Process ForkPoolWorker-25:\n",
      "Process ForkPoolWorker-4:\n",
      "Process ForkPoolWorker-8:\n",
      "Process ForkPoolWorker-1:\n",
      "Process ForkPoolWorker-34:\n",
      "Process ForkPoolWorker-13:\n",
      "Traceback (most recent call last):\n",
      "  File \"/usr/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/usr/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "  File \"/usr/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "Traceback (most recent call last):\n",
      "Traceback (most recent call last):\n",
      "Exception ignored in: <bound method Context.__del__ of <zmq.sugar.context.Context object at 0x7f52be4e3b38>>\n",
      "Traceback (most recent call last):\n",
      "  File \"/usr/local/lib/python3.6/dist-packages/zmq/sugar/context.py\", line 46, in __del__\n",
      "    self.term()\n",
      "  File \"zmq/backend/cython/context.pyx\", line 136, in zmq.backend.cython.context.Context.term\n",
      "  File \"zmq/backend/cython/checkrc.pxd\", line 12, in zmq.backend.cython.checkrc._check_rc\n",
      "KeyboardInterrupt: \n",
      "  File \"/usr/lib/python3.6/multiprocessing/process.py\", line 258, in _bootstrap\n",
      "    self.run()\n",
      "  File \"/usr/lib/python3.6/multiprocessing/process.py\", line 93, in run\n",
      "    self._target(*self._args, **self._kwargs)\n",
      "  File \"/usr/lib/python3.6/multiprocessing/pool.py\", line 108, in worker\n",
      "    task = get()\n",
      "  File \"/usr/lib/python3.6/multiprocessing/queues.py\", line 334, in get\n",
      "    with self._rlock:\n",
      "  File \"/usr/lib/python3.6/multiprocessing/synchronize.py\", line 95, in __enter__\n",
      "    return self._semlock.__enter__()\n",
      "KeyboardInterrupt\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "sys.path.append('../../')\n",
    "from DeepTCR.DeepTCR import DeepTCR_WF\n",
    "\n",
    "# Instantiate training object\n",
    "DTCR_WF = DeepTCR_WF('Tutorial')\n",
    "\n",
    "#Load Data from directories\n",
    "DTCR_WF.Get_Data(directory='../../Data/Rudqvist',Load_Prev_Data=False,aggregate_by_aa=True,\n",
    "               aa_column_beta=1,count_column=2,v_beta_column=7,d_beta_column=14,j_beta_column=21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following loading the data, we will split our data into test/train and then train the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W1004 20:48:29.909550 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/functions/Layers.py:130: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "W1004 20:48:29.918837 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/functions/Layers.py:140: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
      "\n",
      "W1004 20:48:29.921924 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/functions/Layers.py:141: The name tf.sparse.placeholder is deprecated. Please use tf.compat.v1.sparse.placeholder instead.\n",
      "\n",
      "W1004 20:48:29.930583 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/functions/Layers.py:12: The name tf.get_variable is deprecated. Please use tf.compat.v1.get_variable instead.\n",
      "\n",
      "W1004 20:48:29.932635 139995146635072 deprecation.py:506] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "W1004 20:48:29.976086 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/functions/Layers.py:156: The name tf.variable_scope is deprecated. Please use tf.compat.v1.variable_scope instead.\n",
      "\n",
      "W1004 20:48:30.011341 139995146635072 deprecation.py:323] From ../../DeepTCR/functions/Layers.py:98: conv2d (from tensorflow.python.layers.convolutional) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.keras.layers.Conv2D` instead.\n",
      "W1004 20:48:30.209697 139995146635072 deprecation.py:323] From ../../DeepTCR/functions/Layers.py:99: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.flatten instead.\n",
      "W1004 20:48:30.367146 139995146635072 deprecation.py:323] From ../../DeepTCR/functions/Layers.py:102: dropout (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dropout instead.\n",
      "W1004 20:48:30.900394 139995146635072 lazy_loader.py:50] \n",
      "The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
      "For more information, please see:\n",
      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
      "  * https://github.com/tensorflow/addons\n",
      "  * https://github.com/tensorflow/io (for I/O related ops)\n",
      "If you depend on functionality not listed there, please file an issue.\n",
      "\n",
      "W1004 20:48:30.901713 139995146635072 deprecation.py:323] From ../../DeepTCR/functions/MIL.py:50: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use keras.layers.dense instead.\n",
      "W1004 20:48:31.988414 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/DeepTCR.py:3321: The name tf.trainable_variables is deprecated. Please use tf.compat.v1.trainable_variables instead.\n",
      "\n",
      "W1004 20:48:31.989610 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/DeepTCR.py:3322: The name tf.losses.get_regularization_loss is deprecated. Please use tf.compat.v1.losses.get_regularization_loss instead.\n",
      "\n",
      "W1004 20:48:31.991455 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/DeepTCR.py:3326: The name tf.train.AdamOptimizer is deprecated. Please use tf.compat.v1.train.AdamOptimizer instead.\n",
      "\n",
      "W1004 20:48:32.946830 139995146635072 deprecation.py:323] From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/math_grad.py:1205: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "W1004 20:48:36.534812 139995146635072 deprecation_wrapper.py:119] From ../../DeepTCR/DeepTCR.py:3342: The name tf.train.Saver is deprecated. Please use tf.compat.v1.train.Saver instead.\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training_Statistics: \n",
      " Epoch: 0 Training loss: 1.61578 Validation loss: 1.56924 Testing loss: 1.56026 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.91667\n",
      "Training_Statistics: \n",
      " Epoch: 1 Training loss: 1.56478 Validation loss: 1.52729 Testing loss: 1.51791 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.91667\n",
      "Training_Statistics: \n",
      " Epoch: 2 Training loss: 1.51916 Validation loss: 1.48931 Testing loss: 1.48005 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.91667\n",
      "Training_Statistics: \n",
      " Epoch: 3 Training loss: 1.47777 Validation loss: 1.45522 Testing loss: 1.44644 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.91667\n",
      "Training_Statistics: \n",
      " Epoch: 4 Training loss: 1.44084 Validation loss: 1.42605 Testing loss: 1.41791 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.91667\n",
      "Training_Statistics: \n",
      " Epoch: 5 Training loss: 1.40928 Validation loss: 1.40369 Testing loss: 1.39617 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 6 Training loss: 1.38495 Validation loss: 1.38899 Testing loss: 1.38200 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 7 Training loss: 1.36883 Validation loss: 1.38212 Testing loss: 1.37567 Training Accuracy: 0.33333 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 8 Training loss: 1.36087 Validation loss: 1.38149 Testing loss: 1.37567 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 9 Training loss: 1.35942 Validation loss: 1.38390 Testing loss: 1.37879 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 10 Training loss: 1.36121 Validation loss: 1.38635 Testing loss: 1.38198 Training Accuracy: 0.25 Validation Accuracy: 0.5 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 11 Training loss: 1.36275 Validation loss: 1.38719 Testing loss: 1.38337 Training Accuracy: 0.41667 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 12 Training loss: 1.36210 Validation loss: 1.38611 Testing loss: 1.38266 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 13 Training loss: 1.35890 Validation loss: 1.38364 Testing loss: 1.38035 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 14 Training loss: 1.35360 Validation loss: 1.38037 Testing loss: 1.37734 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 15 Training loss: 1.34712 Validation loss: 1.37683 Testing loss: 1.37428 Training Accuracy: 0.25 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 16 Training loss: 1.34020 Validation loss: 1.37357 Testing loss: 1.37171 Training Accuracy: 0.41667 Validation Accuracy: 0.5 Testing Accuracy: 0.25 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 17 Training loss: 1.33346 Validation loss: 1.37099 Testing loss: 1.36986 Training Accuracy: 0.58333 Validation Accuracy: 0.5 Testing Accuracy: 0.5 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 18 Training loss: 1.32741 Validation loss: 1.36914 Testing loss: 1.36867 Training Accuracy: 0.58333 Validation Accuracy: 0.5 Testing Accuracy: 0.5 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 19 Training loss: 1.32211 Validation loss: 1.36789 Testing loss: 1.36809 Training Accuracy: 0.66667 Validation Accuracy: 0.5 Testing Accuracy: 0.5 Testing AUC: 0.75\n",
      "Training_Statistics: \n",
      " Epoch: 20 Training loss: 1.31733 Validation loss: 1.36680 Testing loss: 1.36803 Training Accuracy: 0.75 Validation Accuracy: 0.5 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 21 Training loss: 1.31274 Validation loss: 1.36572 Testing loss: 1.36804 Training Accuracy: 0.75 Validation Accuracy: 0.5 Testing Accuracy: 0.0 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 22 Training loss: 1.30827 Validation loss: 1.36445 Testing loss: 1.36810 Training Accuracy: 0.58333 Validation Accuracy: 0.25 Testing Accuracy: 0.0 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 23 Training loss: 1.30376 Validation loss: 1.36300 Testing loss: 1.36805 Training Accuracy: 0.41667 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 24 Training loss: 1.29912 Validation loss: 1.36147 Testing loss: 1.36789 Training Accuracy: 0.5 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 25 Training loss: 1.29432 Validation loss: 1.35980 Testing loss: 1.36752 Training Accuracy: 0.5 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 26 Training loss: 1.28944 Validation loss: 1.35794 Testing loss: 1.36702 Training Accuracy: 0.41667 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 27 Training loss: 1.28449 Validation loss: 1.35588 Testing loss: 1.36639 Training Accuracy: 0.33333 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Training_Statistics: \n",
      " Epoch: 28 Training loss: 1.27941 Validation loss: 1.35367 Testing loss: 1.36565 Training Accuracy: 0.33333 Validation Accuracy: 0.25 Testing Accuracy: 0.25 Testing AUC: 0.66667\n",
      "Done Training\n"
     ]
    }
   ],
   "source": [
    "DTCR_WF.Get_Train_Valid_Test(test_size=0.25)\n",
    "DTCR_WF.Train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following training, we can view the performance through plotting the ROC curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEKCAYAAAAMzhLIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xl8TNf7wPHPySIRu1i/lEQsCUnEHvu+K6oUVbTVWmIpWqUbqvorWmktQWmrqJbSFrW1aNTSIpbYib2SqtoSRNaZ8/tjYpqQZZDJZHner1denXvn3jvP3I555txz7nOU1hohhBAiLXa2DkAIIUT2JolCCCFEuiRRCCGESJckCiGEEOmSRCGEECJdkiiEEEKkSxKFEEKIdEmiEEIIkS5JFEIIIdLlYOsAHlWJEiW0m5ubrcMQQogc5cCBA9e11iUfZ98clyjc3NzYv3+/rcMQQogcRSl16XH3lUtPQggh0iWJQgghRLokUQghhEiXJAohhBDpkkQhhBAiXVZLFEqpr5RS/yqljqXxvFJKzVZKnVVKHVFK1bZWLEIIIR6fNVsUXwMd0nm+I1Al6W8wMN+KsQghhHhMVksUWusdwM10NukGLNUme4CiSqmy1opHCCHyqvh4wxPtb8sb7soBl5Mthyetu5LeTsdvHMdniY814xJCPGDC9wZqn9O2DkPYSI7ozFZKDVZK7VdKyS3ZQtiAJIm8zZYtigjgqWTL5ZPWPURrvRBYCJDfPb8+OvCo9aMTmW9ykaT/Rtk2DvHITn7kBYDXqZM2jkRk5MSJaxw8eIUXXvAFQGvNpUtR4F7ssY9pyxbFOmBA0ugnfyBKa53uZSchhBCpu3cvgbff3kbNmgt45ZV1nD1r6iJWSuHmVvSJjm21FoVS6jugBVBCKRUOTAIcAbTWC4CNQCfgLHAPeMlasQghRG62adMZhg/fyIULkQAMGlQHV9f8mXZ8qyUKrXXfDJ7XwHBrvb4QQuR2ERG3GT36F1avPgGAr29pFizoTMOGT2Ww56PJcWXGhRBCmAwfvpG1a0/j4uLIlCkteO01fxwcMr9HQRKFEELkIImJRnMymD69DY6O9syc2Y4KFYpY7TVzxPBYIYTI66KiYhk5ciOdO3+L6co9VKtWglWrelk1SYC0KIQQIlvTWrNq1QlGj97MlSt3sbdXhIb+Q61aWVfIQhKFEEJkU+fO3WTEiE1s3nwWgIYNy7NgQRd8fUtnaRySKIQQIhv65JM/eO+9YGJjEyla1Jnp09vwyiu1sbNTWR6LJAohhMiG7t1LIDY2kf79ffnkk3aUKlXAZrFIohBCiGzg2rVoTp++QZMmFQAYP74xLVq40axZRRtHJqOehBDCpoxGzRdfHKRatbn06LGSmzdjAHBycsgWSQKkRSGEEDZz7Ni/DB26nt27TTMutG1biXv3EihePPPKb2QGSRRCCJHFoqPjmTLldwID95CYaKR06QJ89lkHeveugVJZ31mdEUkUQgiRxXr2XMXmzWdRCgIC6vLhh60pWtTZ1mGlSRKFEEJksfHjG3P16l3mz+9MgwblbR1OhiRRCCGEFSUmGpkzZy8XL0Yya1ZHAFq0cGP//sE2uSficUiiEEIIK9m3L4IhQ9YTGvoPAIMH16FGjVIAOSZJgAyPFUKITBcZGUtAwAb8/b8gNPQfKlYsws8/9zUniZxGWhRCCJGJVqw4xujRm7l6NRoHBztef70h773XjAIF8tk6tMcmiUIIITLRr7+e4+rVaBo3for58zvj45O1BfysQRKFEEI8gbi4RCIi7lCpUjEAZsxoS9OmFRg40C9H9UOkR/oohBDiMf322wV8fRfQufO3xMcbAChRwoWXXqqVa5IESKIQQohHdvXqXfr3/4nWrZcSFnYDgPDw2zaOynrk0pMQQljIaNQsWnSACRO2ERkZi7OzA+++25Rx4xqTL5+9rcOzGkkUQghhoWeeWcm6dacBaN/eg6CgTnh4FLdxVNYnl56EEMJCPXp4UqZMQVau7MmmTf3yRJIAaVEIIUSa1q07TXj4bQIC6gEwYEBNevTwolAhJxtHlrUkUQghxAP++iuKUaM2sXbtaZyc7OnQoTKVKhVDKZXnkgRIohBCCLOEBAOzZ+9l0qTtREcnUKhQPqZObUXFikVsHZpNSaIQQghgz55whgxZz5EjVwHo1as6n37annLlCts4MtuTRCGEEMB77wVz5MhV3N2LMnduJzp1qmLrkLINSRRCiDxJa82dO/EULmzqc5g7tyNLlx7mnXea4eLiaOPoshcZHiuEyHNOn75OmzbL6NFjJVprAKpVK8GHH7aWJJEKaVEIIfKM2NhEPvpoJ9Om7SY+3oCra34uXozE3b2YrUPL1qzaolBKdVBKnVZKnVVKTUjl+QpKqWCl1CGl1BGlVCdrxiOEyLu2bDmHj898pkzZQXy8gZdf9uP06RGSJCxgtRaFUsoeCALaAuFAiFJqndb6RLLN3gW+11rPV0pVBzYCbtaKSQiR92itGTRoHYsXhwJQvXpJFizoTNOmFW0cWc5hzUtP9YGzWuvzAEqpFUA3IHmi0MD9sWdFgL+tGI8QIg9SSuHmVpT8+R2YOLE5Y8c2zNUF/KzBmomiHHA52XI40OCBbSYDvyqlRgIFgDZWjEcIkUeEhv7DlSt36NjRNMR1/PjG9O/vK5eZHpOtRz31Bb7WWpcHOgHLlFIPxaSUGqyU2q+U2p/lEQohcow7d+IYO/YX6tRZyMCBa7h5MwYAJycHSRJPwJotigjgqWTL5ZPWJTcI6ACgtf5TKeUMlAD+Tb6R1nohsBAgv3t+ba2AhRA5k9aaNWtOMWrUZsLDb2Nnp3j+eR8cHW39Wzh3sGaiCAGqKKXcMSWIPsDzD2zzF9Aa+Fop5QU4A9esGJMQIpe5dCmSESM2sX59GAB16/6Pzz/vQu3aZW0cWe5htUShtU5USo0AfgHsga+01seVUlOA/VrrdcDrwCKl1BhMHdsv6vt3vwghRAa01jz77PccOHCFwoWd+L//a8XQoXWxt5eWRGay6g13WuuNmIa8Jl83MdnjE0Bja8YghMh9jEaNnZ1CKcUnn7RjwYL9fPppe8qWLWTr0HIluTNbCJFj3LhxjwkTtgKwaFFXAFq0cKNFCzcbRpX7SftMCJHtaa1ZsiQUT88gvvjiEEuXHiE8/Latw8ozpEUhhMjWTp68xrBhG/j990uAqQUxf35nypeXeSKyiiQKIUS2pLVm4sRgpk/fTUKCkRIlXJg5sx39+/uilLJ1eHmKJAohRLaklCIi4g4JCUZefbU206a1oXjx/LYOK0+SRCGEyDb+/vsO16/fw9e3NAAzZrRl0KBaNG5cwcaR5W3SmS2EsDmDwcjcufvw8gqiT5/VxMcbAChRwkWSRDYgLQohhE0dPHiFIUPWs3+/qXh0s2YVuX07jhIlXGwcmbjPokShlMoHVNBan7VyPEKIPOL27Tjee+835s4NwWjUlC9fmNmzO9C9u6d0VmczGSYKpVRnIBDIB7grpfyASVrrZ6wdnBAid9Ja06zZYg4fvoq9vWLsWH8mT25BoUJOtg5NpMKSPoopmOaRiATQWocCla0ZlBAid1NKMWaMP/Xrl2P//sHMnNlekkQ2ZsmlpwStdeQDTUEp3CeEsFh8vIHAwD+xt1eMG2cq7zZgQE1eeMFXCvjlAJYkipNKqecAu6SS4aOAPdYNSwiRW+zceYmhQzdw4sQ1nJzsGTCgJqVLF0Qphb299EXkBJak8hFAHcAI/AjEAa9ZMyghRM53/fo9Xn55Lc2afc2JE9eoUqU469c/T+nSBW0dmnhElrQo2mutxwPj769QSvXAlDSEECIFrTVffx3KuHFbuHEjhnz57HnrrSZMmNAEZ2cZkZ8TWdKieDeVde9kdiBCiNzjm2+OcuNGDK1auXPkyFAmT24hSSIHS/P/nFKqPab5rMsppQKTPVUY02UoIYQA4N69BKKiYilbthBKKebN60RIyN/06+cj90TkAuml+H+BY0AscDzZ+jvABGsGJYTIOTZtOsPw4RupVKkYW7b0RylFtWolqFathK1DE5kkzUShtT4EHFJKLddax2ZhTEKIHCAi4jajR//C6tUnAChUyIkbN2Kk9EYuZMlFw3JKqQ+B6oDz/ZVa66pWi0oIkW0ZDEaCgkJ4993fuHMnngIFHJkypSWjRjXAwUHuiciNLEkUXwNTgU+AjsBLyA13QuRJRqOmefOv2b37MgDdu3sya1YHKlQoYuPIhDVZkv5dtNa/AGitz2mt38WUMIQQeYydnaJdOw+eeqowa9f24aefekuSyAMsaVHEKaXsgHNKqaFABFDIumEJIbIDrTXff38c32Trxo9vzNixDSlYMJ/N4hJZy5IWxRigAKbSHY2BV4GXrRmUEML2zp27SYcOy+nT54cU652cHCRJ5DEZtii01nuTHt4B+gMopcpZMyghhO3ExSXy8cd/8OGHO4mNTaRYMeeMdxK5WrotCqVUPaVUd6VUiaTlGkqppcDe9PYTQuRM27dfxM/vc957L5jY2ET69/fl1KkRtg5L2FiaiUIp9RGwHOgHbFZKTQaCgcOADI0VIpcxGIwEBGzg1KnrVKvmym+/DWDp0mcoVaqArUMTNpbepaduQE2tdYxSqjhwGfDRWp/PmtCEENZmNGpiYxNxcXHE3t6O+fM7s2PHJd58szFOTlKbSZik90mI1VrHAGitbyqlwiRJCJF7HD16laFDN+Dp6cqXX3YDoHlzN5o3d7NtYCLbSS9RVFJK3S8lrjDNl20uLa617mHVyIQQVhEdHc+UKb8TGLiHxEQjFy7c4tatGIoVy2/r0EQ2lV6iePaB5bnWDEQIYX0//3yaESM28ddfUSgFAQF1+fDD1hQtKiObRNrSKwq4LSsDEUJYT2Kikd69V/PjjycB8PMrw+efd6F+fRnpLjImvVVC5AEODnYUKeJEwYL5+OCDlowYUV8K+AmLWfWTopTqoJQ6rZQ6q5RKdQ4LpdRzSqkTSqnjSqlvrRmPEHnJ3r3h7N0bbl7++OO2nDw5nNGj/SVJiEdicYtCKeWktY57hO3tgSCgLRAOhCil1mmtTyTbpgrwFtBYa31LKVXK8tCFEKmJjIzlrbe28vnnB/D0LEFo6FDy5bPH1VXmiRCPJ8OfFUqp+kqpo8CZpOWaSqk5Fhy7PnBWa31eax0PrMB0b0ZyrwJBWutbAFrrfx8peiGEmdaab789iqfnXBYsOIC9vR1du1bDYJCZi8WTsaRFMRvoAqwB0FofVkq1tGC/cphu0rsvHGjwwDZVAZRSuwF7YLLWerMFxxZCJHPmzA0CAjaydavpVqfGjZ9iwYIueHtLI108OUsShZ3W+tIDE6QbMvH1qwAtgPLADqWUj9Y6MvlGSqnBwGAAZzcZxidEcgkJBlq1Wkp4+G2KF8/PjBlteOmlWtjZqYx3FsICliSKy0qp+oBO6ncYCYRZsF8E8FSy5fJJ65ILB/ZqrROAC0qpMEyJIyT5RlrrhcBCgPzu+WV2PSEwXWpSSuHoaM+HH7YiOPgiM2a0oWRJqc0kMpclQx+GAWOBCsBVwD9pXUZCgCpKKXelVD6gD7DugW3WYGpNkFShtiogZUKESMfVq3fp3/8npk7dYV43YEBNFi/uJklCWIUlLYpErXWfRz2w1jpRKTUC+AVT/8NXWuvjSqkpwH6t9bqk59oppU5gupw1Tmt941FfS4i8wGjULFp0gAkTthEZGUvRos6MHu1PoUJOtg5N5HKWJIoQpdRpYCXwo9b6jqUH11pvBDY+sG5isscaU2tlrKXHFCIvOnz4H4YO3cCePab7Ijp0qExQUCdJEiJLWDLDnYdSqhGmS0fvK6VCgRVa6xVWj06IPC4hwcBbb23js8/2YDBoypYtyKxZHejZszoPDDARwmosuj1Ta/2H1noUUBu4jWlCIyGElTk42HHo0D8YjZqRI+tz8uRwevWqIUlCZKkMWxRKqYKYbpTrA3gBa4FGVo5LiDzrr7+iMBiMuLsXQynFggWdiYqKo27d/9k6NJFHWdJHcQz4GZihtd5p5XiEyLMSEgzMmrWXSZO207BhebZs6Y9SiipVXG0dmsjjLEkUlbTWUgNACCv688/LDB26gSNHrgJQvHh+7t1LoECBfDaOTIh0EoVSaqbW+nXgB6XUQze5yQx3Qjy5W7dimDBhKwsXHgTA3b0oQUGd6Nixio0jE+I/6bUoVib9V2a2E8IK4uIS8fP7nL/+isLR0Y5x4xrxzjvNcHFxtHVoQqSQ3gx3+5IeemmtUySLpBvpZAY8IZ6Ak5MDgwbVYtu2C8yf35nq1UvaOiQhUmXJ8NiXU1k3KLMDESK3i41NZNKkYL799qh53dtvN2X79oGSJES2ll4fRW9MQ2LdlVI/JnuqEBCZ+l5CiNRs2XKOgICNnD17k1KlCvDMM57kz+8oM82JHCG9Pop9wA1MVV+Dkq2/AxyyZlBC5Bb//HOXsWN/4bvvjgFQo0ZJFizoQv780g8hco70+iguABeArVkXjhC5g8Fg5PPPD/D229uIioojf34HJk1qzpgxDcmXz97W4QnxSNK79PS71rq5UuoWkHx4rMJUz6+41aMTIocyGDRz5uwjKiqOTp2qMHduR9zdi9k6LCEeS3qXnu5Pd1oiKwIRIqe7cycOg0FTtKgz+fLZs2jR01y9epcePbykNpPI0dLsSUt2N/ZTgL3W2gA0BIYAMjuKEEm01vz440m8vIJ4/fVfzOubNKnAs89KlVeR81ky5GINpmlQPYDFmKYq/daqUQmRQ1y8GEnXrit49tnviYi4w7Fj14iNTbR1WEJkKksShTFpTusewByt9RignHXDEiJ7S0gwMH36LqpXD2L9+jAKF3Zi7tyO/PHHyzg7W1JCTYicw6KpUJVSvYD+QPekdTK2T+RZ9+4l4O//BUeP/gtAnz7eBAa2o2zZQjaOTAjrsCRRvAwEYCozfl4p5Q58Z92whMi+XFwcqVv3f9y7l8C8eZ1p187D1iEJYVWWTIV6TCk1CqislPIEzmqtP7R+aEJkD1prli49jIdHcZo0qQDAp5+2J18+e7lxTuQJlsxw1xRYBkRguoeijFKqv9Z6t7WDE8LWTp68xrBhG/j990t4eZUgNHQo+fLZU6SIs61DEyLLWHLp6VOgk9b6BIBSygtT4qhrzcCEsKWYmAQ+/HAnM2bsJiHBSMmSLrz1VhMcHaU2k8h7LEkU+e4nCQCt9UmllEy7JXKtzZvPMnz4Rs6fvwXAq6/WZtq0NhQvnt/GkQlhG5YkioNKqQXAN0nL/ZCigCKXuns3nv79f+L69Xt4e5diwYLONG5cwdZhCWFTliSKocAo4M2k5Z3AHKtFJEQWMxiMGI0aR0d7ChbMx6xZHQgPv82YMf44OkoBPyHSTRRKKR/AA/hJaz0ja0ISIuscOPA3Q4asp1u3arz3XnMAnn/ex8ZRCZG9pNkzp5R6G1P5jn7AFqVUajPdCZEj3b4dx2uvbaJ+/S84cOAKy5YdISHBYOuwhMiW0mtR9AN8tdbRSqmSwEbgq6wJSwjr0FqzevUJXnttM1eu3MXeXjF2rD/vv99SLjMJkYb0EkWc1joaQGt9TSkl4wJFjnbnThy9e69m06azADRoUI4FC7rg51fGxpEJkb2llygqJZsrWwEeyefO1lr3sGpkQmSyggXzERdnoEgRJ6ZNa8PgwXWws5MS4EJkJL1E8ewDy3OtGYgQ1rBjxyXKli1IlSquKKX46quuODs7ULp0QVuHJkSOkd6c2duyMhAhMtP16/d4880tLF4cSuvW7mzZ0h+lFBUrFrV1aELkOFbtd1BKdVBKnVZKnVVKTUhnu2eVUlopJWVBxBMxGjVffXWIatXmsnhxKPny2dO0aQUMBp3xzkKIVFlthhWllD0QBLQFwoEQpdS65OVAkrYrBLwG7LVWLCJvOH78X4YN28DOnX8B0Lq1O/PmdaZqVVcbRyZEzmZxolBKOWmt4x7h2PUxlSQ/n7T/CqAbcOKB7T4ApgPjHuHYQqQQFRWLv/+X3L0bT6lSBQgMbMfzz/vIfNVCZIIMLz0ppeorpY4CZ5KWayqlLCnhUQ64nGw5nAemUFVK1Qae0lpvsDxkIf6jtemSUpEizowf35ihQ+tw6tRw+vXzlSQhRCaxpEUxG+iC6S5ttNaHlVItn/SFk+7LCARetGDbwcBgAGc3mQdAQETEbV57bTPdulWjf/+aALzzTlNJDkJYgSWd2XZa60sPrLOk1kEE8FSy5fJJ6+4rBHgD25VSFwF/YF1qHdpa64Va67paa+nszuMSE43MmrUHT88gfvjhJJMmbcdgMAJIkhDCSixpUVxWStUHdFIH9UggzIL9QoAqSXNsRwB9gOfvP6m1jgJK3F9WSm0H3tBa77c8fJGXhIREMHToBg4evAJA9+6ezJ7dAXt7KRoghDVZkiiGYbr8VAG4CmxNWpcurXWiUmoE8AtgD3yltT6ulJoC7Ndar3v8sEVeEh0dz/jxW5k3LwStoUKFIsyZ05GuXavZOjQh8oQME4XW+l9MrYFHprXeiKmYYPJ1E9PYtsXjvIbI/Rwc7Ni69Tx2doqxYxsyaVJzChSQSRaFyCoZJgql1CLgobuVtNaDrRKREMC5czcpWtQZV1cXnJwcWLbsGZydHfDxKW3r0ITIcyy5uLsV2Jb0txsoBTzK/RRCWCwuLpGpU3fg7T2f8eO3mtfXq1dOkoQQNmLJpaeVyZeVUsuAXVaLSORZ27dfZNiwDZw6dR0wjXAyGIzSWS2EjT1OCQ93QH7aiUzz77/RjBu3haVLDwNQrZor8+d3pmVLdxtHJoQAy/oobvFfH4UdcBNIs8CfEI/i+vV7eHkFcfNmDE5O9rzzTlPefLMxTk5WK0MmhHhE6f5rVKY7mGry341yRn2/ZoIQmaBECRe6datGePht5s3rTOXKxW0dkhDiAekmCq21Vkpt1Fp7Z1VAIvcbP34LnTtXpVmzigDMm9cZJyd7ubNaiGzKkl7CUKVULatHIvKMGTP+ICBgA0ajqXHq7OwgSUKIbCzNRKGUut/aqIVpLonTSqmDSqlDSqmDWROeyA0uX46iR4//Bs/VqlWGxYu7yXzVQuQQ6V162gfUBrpmUSwil0lMNDJ79l4mTgwmOjoBfE3r9+17FQcHGfIqRE6RXqJQAFrrc1kUi8hlbt+O46OPdhEdncCzz3qZ1+fVJJGQkEB4eDixsbG2DuWRJQTNBeDkyZM2jkRkxNnZmfLly+Po6Jhpx0wvUZRUSo1N60mtdWCmRSFyjcjIWPLnd8DJyYHixfPz+eddcHKyp3PnqjD5VVuHZ1Ph4eEUKlQINze3HNcnE2MwzSyQ38srgy2FLWmtuXHjBuHh4bi7Z959SOn9tLMHCmKaNyK1PyHMtNZ8++1RqlWby4wZu83re/TwMiUJQWxsLK6urjkuSYicQymFq6trprda02tRXNFaT8nUVxO5UljYDQICNrBt2wUAduz4C621fCGmQs6JsDZrfMYy7KMQIi2xsYlMn76L//u/XcTHGyhePD8ff9yWF1/0ky9EIXKR9C49tc6yKESO888/d/H1nc/kyb8TH2/gxRf9OH16BC+/XEuGvWZjs2bNwtvbmxo1avDZZ5+Z17/44ousXr06xbYFCxY0P+46dChlGzWiS5cuKba5cOECDRo0oHLlyvTu3Zv4+PhUX3fNmjVMmZJ9L1BorRk1ahSVK1fG19eXgwdTvwMgPj6ewYMHU7VqVTw9Pfnhhx/Mz33//fdUr16dGjVq8Pzz5sk8+euvv2jXrh1eXl5Ur16dixcvAtC0aVP8/Pzw8/Pjf//7H927dwdg/fr1TJyY6rQ9tqO1zlF/zm7OWtie0WjUrVot0V5ec/X27Rcs22lSYdNfHnXixAmbvv7Ro0d1jRo1dHR0tE5ISNCtW7fWZ86c0VprPXDgQL1q1aoU2xcoUMD8eMOiRXrVnDm6c+fOKbbp1auX/u6777TWWg8ZMkTPmzcv1ddu2LChvnbtmsWxJiQkWLxtZtiwYYPu0KGDNhqN+s8//9T169dPdbuJEyfqd955R2uttcFgML+nsLAw7efnp2/evKm11vrq1avmfZo3b65//fVXrbXWd+7c0dHR0Q8dt0ePHnrJkiVaa9O/LT8/v1S3s1RqnzVMM4s+1veuVF4TFjEaNYsWHaBlS3eqVjV1yH77bQ+KFctPvnz2tg4vx3GbsMEqx704rXOaz508eZIGDRrg4uICQPPmzfnxxx958803MzxuS39/doSEpFintea3337j22+/BWDgwIFMnjyZYcNSzpQcFhaGk5MTJUqUAODnn39m6tSpxMfH4+rqyvLlyyldujSTJ0/m3LlznD9/ngoVKvDNN98wYcIEtm/fTlxcHMOHD2fIkCHcvXuXbt26cevWLRISEpg6dSrdunV7pPP0oLVr1zJgwACUUvj7+xMZGcmVK1coW7Zsiu2++uorTp06BYCdnZ35PS1atIjhw4dTrFgxAEqVKgXAiRMnSExMpG3btkDKVtp9t2/f5rfffmPx4sWAqY+hRYsWrF+/nueee+6J3ldmyZsD2sUjOXz4Hxo3/oqhQzcQELABnVQXsnTpgpIkchBvb2927tzJjRs3uHfvHhs3buTy5cvm58eNG2e+FOLn55fh8W7cuEHRokVxcDD93ixfvjwREREPbbd7925q165tXm7SpAl79uzh0KFD9OnThxkzZpifO3HiBFu3buW7777jyy+/pEiRIoSEhBASEsKiRYu4cOECzs7O/PTTTxw8eJDg4GBef/1182cyud69e6d4P/f/li5d+tC2ERERPPXUU+bl1N5LZGQkAO+99x61a9emV69eXL16FTAlw7CwMBo3boy/vz+bN282ry9atCg9evSgVq1ajBs3DkPSUOP71qxZQ+vWrSlcuLB5Xd26ddm5c2caZz7rSYtCpOnu3XgmT97OZ5/twWDQ/O9/hRg6tK6tw8oV0vvlby1eXl6MHz+edu3aUaBAAfz8/LC3/y/Rf/zxx/Ts2dO8nNqv38dx5coVSpYsaV4ODw+nd+/eXLlyhfj4+BTj/bt27Ur+/PkB+PXXXzly5Ii57yQqKoozZ85QvnwIiP2KAAAgAElEQVR53n77bXbs2IGdnR0RERFcvXqVMmXKpHjdlStTzLn2xBITEwkPD6dRo0YEBgYSGBjIG2+8wbJly0hMTOTMmTNs376d8PBwmjVrxtGjR0lMTGTnzp0cOnSIChUq0Lt3b77++msGDRpkPu53333HK6+8kuK1SpUqxd9//52p8T8JaVGIVK1ZcwovryBmzvwTrWHkyPqcPDmcnj2ry4imHGzQoEEcOHCAHTt2UKxYMapWffx7XFxdXYmMjCQxMREwJYBy5co9tF3+/PlTjOsfOXIkI0aM4OjRo3z++ecpnitQoID5sdaaOXPmEBoaSmhoKBcuXKBdu3YsX76ca9euceDAAUJDQyldunSq9w08SouiXLlyKVpXqb0XV1dXXFxc6NGjBwC9evUyd3qXL1+erl274ujoiLu7O1WrVjUnNT8/PypVqoSDgwPdu3dP0VF+/fp19u3bR+fOKX84xMbGmhNmdiCJQjwkIuI2ffqsJjz8NnXqlGXv3leYPbsjhQs72To08YT+/fdfwDQS58cff0wxOudRKaVo2bKl+Rf/kiVLUu0r8PLy4uzZs+blqKgo85fwkiVL0jx++/btmT9/PgkJCYDpMk50dDRRUVGUKlUKR0dHgoODuXTpUqr7r1y50pxkkv8NGDDgoW27du3K0qVL0VqzZ88eihQp8lD/hFKKp59+mu3btwOwbds2qlevDkD37t3N669fv05YWBiVKlWiXr16REZGcu3aNQB+++038z4Aq1evpkuXLjg7O6d4rbCwMLy9s9HsDo/bC26rPxn1ZB3x8YnaaDSalz/5ZLeePXuPTkw0ZN6LyKgnW4egmzRpor28vLSvr6/eunWreX1Go54a1a6tSxQrpp2dnXW5cuX05s2btdZanzt3TterV097eHjonj176tjY2IdeMzo6WlevXt38+VqzZo12d3fXtWvX1m+88YZu3ry51lrrSZMm6Y8//ti8n8Fg0G+99Zb29vbWNWrU0C1atNCRkZH62rVr2t/fX3t7e+sXX3xRe3p66gsXLjzReTEajTogIEBXqlRJe3t765CQEPNzNWvWND++ePGibtq0qfbx8dGtWrXSly5dMu8/ZswY7eXlpb29vc0jwbTW+tdff9U+Pj7a29tbDxw4UMfFxZmfa968ud60adND8XTu3FkfOXLksd9PZo96UjqVTqDsLL97fh1zIcbWYeQqf/xxmaFD1zNuXCP6969pvReaXCTpv1HWe41s7OTJk3jl0FpJMceOAZD/MX/lvvbaazz99NO0adMmM8PKla5evcrzzz/Ptm3bHvsYqX3WlFIHtNaP1ckol57ysJs3Yxgy5GcaN/6Ko0f/Zd68/amOHhHiSb399tvcu3fP1mHkCH/99RczZ860dRgpyKinPEhrzTffHOH113/l2rV7ODra8eabjXnnnabSUS2sonTp0nTtKlPbWKJevXq2DuEhkijymKtX79K37w8EB18EoHnzisyf3xkvr5Lp7yiEyLMkUeQxRYs6c+XKXUqUcOGTT9oyYEBNaUUIIdIliSIP2LLlHLVrl8XV1QUnJwdWrepF2bIFcXV1sXVoQogcQDqzc7ErV+7Qt+8PtGv3DePHbzWv9/YuJUlCCGExSRS5kMFgZN68EDw9g1ix4hj58ztQrZqrjGgS/PPPP/Tp0wcPDw/q1KlDp06dCAsLe+Ljplam/FFcuXLloRLm2c2SJUuoUqUKVapUSfdGwTlz5uDp6UmNGjVSFFw8cuQIDRs2pEaNGvj4+JjvJk+rdPmYMWPMd5NXrVqVokWLAnDt2jU6dOhgxXf6MLn0lMscPHiFoUPXExJiqhPTuXMV5s7thJtbURtHJmxNa80zzzzDwIEDWbFiBQCHDx/m6tWrT1TKIzMEBgby6quWz6memJhoLkaYFW7evMn777/P/v37UUpRp04dunbtaq4We19wcDBr167l8OHDODk5me+ET0xM5IUXXmDZsmXUrFmTGzdu4OjoCMCHH35IqVKlCAsLw2g0cvPmTQA+/fRT83HnzJnDoUOHAChZsiRly5Zl9+7dNG7cOCveviSK3OTixUjq11+EwaApV64Qs2d35JlnPKWzOju6f/Nhph837ZsZg4ODcXR0ZOjQoeZ1NWuabrDUWvPmm2+yadMmlFK8++679O7dm+3btzNp0iQK2dlx/MwZer/wAj4+PsyaNYuYmBjWrFmDh4cHAFu3bmXatGncvn2bwMBAunTpQmxsLMOGDWP//v04ODgQGBhIy5YtH4rthx9+YOrUqQBcvHiR/v37Ex0dDcDcuXNp1KgR27dv57333qNYsWKcOnWKsLAwvvnmG2bPnk18fDwNGjRg3rx52NvbM2zYMEJCQoiJiaFnz568//77T3Raf/nlF9q2bUvx4sUBaNu2LZs3b6Zv374ptps/fz4TJkzAyclU7uZ+ufFff/0VX19f8/l2dXU175NW6fLkvvvuuxTvoXv37ixfvjzLEoVVLz0ppToopU4rpc4qpSak8vxYpdQJpdQRpdQ2pVRFa8aT27m5FeWll/wYM8afkyeH06OHlyQJYXbs2DHq1KmT6nM//vgjoaGhHD58mK1btzJu3DiuXLkCmFodsydO5NC6dSxbtoywsDD27dvHK6+8wpw5c8zHuHjxIvv27WPDhg0MHTqU2NhYgoKCUEpx9OhRvvvuOwYOHPhQAb8LFy5QrFixFF+uW7Zs4eDBg6xcuZJRo0aZtz148CCzZs0iLCyMkydPsnLlSnbv3k1oaCj29vYsX74cMP1K379/P0eOHOH333/nyJEjD73njz/+ONWigclf7z5LypCDqUbTzp07adCgAc2bNyckaQ6PsLAwlFK0b9+e2rVrm0urp1e6/L5Lly5x4cIFWrVqZV6X1WXIrdaiUErZA0FAWyAcCFFKrdNan0i22SGgrtb6nlJqGDAD6G2tmHKbixcjGTlyE2+80ZDmzd0AWLjwaUkOOUE2K2Oya9cu+vbti729PaVLlzZ/yRUuXJh69epRNqlMuIeHB+3atQPAx8eH4OBg8zGee+457OzsqFKlCpUqVeLUqVPs2rWLkSNHAuDp6UnFihUJCwvD19fXvN+DZcgTEhIYMWKE+cs/eR9K/fr1zWXJt23bxoEDB8w3qMXExJh/wX///fcsXLiQxMRErly5wokTJ1K8Jpjm3xg3blymnUMwXWK6efMme/bsISQkhOeee47z58+TmJjIrl27CAkJwcXFhdatW1OnTh1q1qyZZuny+1asWEHPnj1TlITP6jLk1rz0VB84q7U+D6CUWgF0A8yJQmsdnGz7PcALVown10hIMBAY+Cfvv/87MTGJXL9+jz//NNW3lyQh0lKjRo3H6nC+/0sfTJdG7i/b2dmZS4zDw589Sz+LD5Yh//TTTyldujSHDx/GaDSmqKz6YBnygQMH8tFHH6U43oULF/jkk08ICQmhWLFivPjii6mWIf/444/NLZDkmjVrxuzZs1OsK1eunLk6LJjKkLdo0eKhfcuXL0+PHj1QSlG/fn3s7Oy4fv065cuXp1mzZubLSp06deLgwYO0atXqodLlX375ZYpjrlixgqCgoBTrsroMuTUvPZUDLidbDk9al5ZBwKbUnlBKDVZK7VdK7c/E+HKkXbv+olatz5kwYRsxMYn06ePNjz9mj+kSRfbWqlUr4uLiWLhwoXndkSNH2LlzJ02bNmXlypUYDAauXbvGjh07qF+//iMdf9WqVRiNRvN0ptWqVaNp06bmL+OwsDD++usvqlWrlmK/qlWrcvHiRfNyVFQUZcuWxc7OjmXLlj00I9x9rVu3ZvXq1eYO45s3b3Lp0iVu375NgQIFKFKkCFevXmXTplS/Vhg3blyqZcgfTBJgKnn+66+/cuvWLW7dusWvv/5K+/btH9que/fu5lZWWFgY8fHxlChRgvbt23P06FHu3btHYmIiv//+O9WrV0+3dDnAqVOnuHXrFg0bNkzxOlldhjxbdGYrpV4A6gLNU3tea70QWAim6rFZGFq2cetWDOPGbeHLL00jHzw8ijFvXmfatfOwcWQip1BK8dNPPzF69GimT5+Os7Mzbm5ufPbZZzRp0oQ///yTmjVNd+rPmDGDMmXKmDtZLVGhQgXq16/P7du3WbBgAc7OzgQEBDBs2DB8fHxwcHDg66+/TtFCAVMrwcPDg7Nnz1K5cmUCAgJ49tlnWbp0KR06dEjRikiuevXqTJ06lXbt2mE0GnF0dCQoKAh/f39q1aqFp6cnTz31VKZ0+BYvXpz33nvPfJlr4sSJ5o7tV155haFDh1K3bl1efvllXn75Zby9vcmXLx9LlixBKUWxYsUYO3Ys9erVQylFp06dzJMVTZ8+nf79+zN69GhKlixpnjsbTK2JPn36PNQ6Cw4OfmiyI2uyWplxpVRDYLLWun3S8lsAWuuPHtiuDTAHaK61/jej4+bVMuM3btzD0zOIqKhYJkxowltvNSF/fkdbh/VopMx4ni0znpGffvqJAwcOmEc+ifQ1a9aMtWvXPjQ8977MLjNuzRZFCFBFKeUORAB9gBTTaSmlagGfAx0sSRJ5zalT13F3L4qTkwOuri4sX96DChWK4On58PA5IXKyZ555hhs3btg6jBzh2rVrjB07Ns0kYQ1W66PQWicCI4BfgJPA91rr40qpKUqp+/WGPwYKAquUUqFKqXXWiicnuXcvgXfe2Yav73xmzNhtXt+unYckCZFrvfLKK7YOIUcoWbIk3bt3z9LXtGofhdZ6I7DxgXUTkz2W6a4esHnzWQICNnDhgml89fXrMtmLEMK2skVntoC//77D6NGbWbXKNHrYx6cUCxZ0oVGjpzLYUwghrEsSRTYQFnaDunUXcudOPC4ujkye3JzRo/1xdLTPeGchhLAySRTZQJUqxalXrxwFCjgyZ05HKlaUAn5CiOxDyozbwO3bcYwevZmwMNMoD6UU69b1Yd26vpIkhFVlZpnxzz77jHv3Hr0PrUWLFuzfn/q9sz179uT8+fOPFU9WmDt3LpUrV0YpxfXr19PcLq2S5AcOHMDHx4fKlSszatQoc+n/mzdv0rZtW6pUqULbtm25desWYLr7fNSoUVSuXBlfX18OHjwIZH2pcUkUWUhrzapVx/H0nMusWXsZNeq/O0YLFMhnw8hEXnC/zHiLFi04d+4cBw4c4KOPPnqoCJ2l0ksUad1NnZ7jx49jMBioVKmSxfs8zus8icaNG7N161YqVky7fun9kuR79+5l3759vP/+++Yv/mHDhrFo0SLOnDnDmTNn2Lx5MwDTpk2jdevWnDlzhtatWzNt2jQANm3aZN524cKFDBs2DEhZajwryKWnLHL+/C1GjNjIpk1nAfD3L8/06TLoK6/yWeJjleMeHXg0zecet8z45MmTKZYvHyfOnKFuo0Z88803zJkzh7///puWLVtSokQJgoODKViwIEOGDGHr1q0EBQURFxfHG2+8QWJiIvXq1WP+/PkP3ZWd3PLly+nWrZt5Oa1S4W5ubvTu3ZstW7bw5ptvUq9ePYYPH861a9dwcXFh0aJFeHp68vPPPzN16lTi4+NxdXVl+fLllC5d+onOb61atTLcJq2S5C1atOD27dv4+/sDMGDAANasWUPHjh1Zu3atuYzHwIEDadGiBdOnT2ft2rUMGDAApRT+/v5ERkZy5coVypYtm6WlxiVRWFl8vIFPPvmDDz7YQWxsIkWLOjNtWmtefbUOdnZSwE9kHUvLjF+/fp169erRrFkzAA4dOsT+H37gf6VK0WbIEHbv3s2oUaMIDAwkODjYXOguOjqaBg0aMHPmTGJjY6lSpQrbtm2jatWqDBgwgPnz5zN69Og049u9e3eK+R0+/PBDihcvjsFgoHXr1hw5csRcAdbV1dV8GaZ169YsWLCAKlWqsHfvXgICAvjtt99o0qQJe/bsQSnFF198wYwZM5g5c2aK1zx9+jS9e6desHr79u3mWeUeRVolySMiIihfvvxD6wGuXr1K2bJlAShTpoy5lZfWscqWLUvdunV59913Hzm+xyGJwsouX45iypTfiYsz0K+fDzNntqN06YK2DkvYWHq//G0hvTLj9evXp3yZMgD4+flx8eJFmjRp8tAx7O3tefbZZwHTF7C7u7t55ryBAwcSFBSUbqJ4sNx4eqXC73+53717lz/++INevXqZ94uLiwNMFV579+7NlStXiI+PN5cnT65atWqEhoY+0rmyNqWURZV3s7LUuCQKK7h1K4aiRZ1RSuHhUZxZszpQuXJxWre2/NqrEJktM8qM29vbpygtnpyzs3OKORMeVfJy4xmVCr9fKNBoNFK0aNFUv+xHjhzJ2LFj6dq1q/kS2oOs0aJIqyR5uXLlCA8PT7G+XDlTQe3SpUubLylduXLFPK9GuXLluHz5cqr7ZGWpcenMzkRGo+arrw5RufIcvvnmvxm1hgypK0lC2FxmlxkvVKgQd+7cSfW5atWqcfHiRc6eNfXJLVu2jObNUy0Obebl5WXe3tJS4YULF8bd3Z1Vq1YBpr6Ww4cPA6Zy5fe/VJOPPHowztRKjYeGhj5WkoC0S5KXLVuWwoULs2fPHrTWLF261Nwn07VrV3OMS5YsSbF+6dKlaK3Zs2cPRYoUMV+iyspS45IoMsnx4//SosXXDBq0jps3Y8yd1kJkF/fLjG/duhUPDw9q1KjBW2+9RZkyZXjmmWfMczq3atXKXGY8PYMHD6ZDhw6pzoHt7OzM4sWL6dWrFz4+PtjZ2aXoRE9N586dzb/Ea9asaS4V/vzzz6fbYbt8+XK+/PJLatasSY0aNVi7di0AkydPplevXtSpUyfVeagfx+zZsylfvjzh4eH4+vqa61Pt37/f/Dh5SfJ69eqlKEk+b948XnnlFSpXroyHhwcdO3YEYMKECWzZsoUqVaqwdetWJkwwzRzdqVMnKlWqROXKlXn11VeZN2+eOZasLDVutTLj1pLdyozfu5fABx/8zief/EliopFSpQrw6aft6dvXW2abe5CUGZcy4+m9RkwMLVu2ZPfu3U90CSuvSK/UeE4qM57rhYXdoH37b7h4MRKlYOjQOvzf/7WmWLGsm6JQiNwif/78vP/++0RERFChQgVbh5OtZXWpcUkUT6BixSI4OztQs2ZpFizogr9/+Yx3EkKkKbXpRcXDsrrUuCSKR5CYaGTBgv307euNq6sLTk4ObN7cj3LlCuPgIN09QojcSRKFhfbti2Do0PUcOvQPoaH/8MUXprmXpDaTECK3k0SRgaioWN555zfmzQtBa6hQoQjdulWzdVhCCJFlJFGkQWvNypXHGTPmF/755y4ODnaMHevPxInNpYCfECJPkQvraTh8+Cp9+/7AP//cpVGjpzh4cDDTp7eVJCFyNHt7e/z8/PD29ubpp58mMjKSo0eP4ufnh5+fH8WLF8fd3R0/Pz/atHm4aGVMTAzNmzfP8qqtj2Lz5s1Uq1aNypUrm6uwPmjBggX4+Pjg5+dHkyZNOHHCNLPkvn37zOeiZs2a/PTTT4DpLuj69eub79WYNGmS+ViDBg2iZs2a+Pr60rNnT+7evQuYSpJ/9dVXVn63WURrnaP+nN2ctbUkJhpSLI8Zs1kvWnRAGwxGq71mnjKpsOkvjzpx4oStQ9AFChQwPx4wYICeOnVqiucHDhyoV61a9dB+944e1feOHtVz587Vn332mcWvZzQatcFgyHjDTJKYmKgrVaqkz507p+Pi4rSvr68+fvz4Q9tFRUWZH69du1a3b99ea611dHS0TkhI0Fpr/ffff+uSJUvqhIQEbTQa9Z07d7TWWsfHx+v69evrP//886FjjRkzRn/00UfmY/n5+VnnjWYgtc8asF8/5veuXHpKEhx8gYCAjXz+eReaNTPVmg8MlKF6wjpOelrnxjuvUyct3rZhw4YcOXIk4w2TWb58Od9++y1gKsjXrVs3bt26RUJCAlOnTqVbt25cvHiR9u3b06BBAw4cOMDGjRs5ffo0kyZNIi4uDg8PDxYvXkzBggWZMmUKP//8MzExMTRq1IjPP//8iW5U3bdvH5UrVzbPadGnTx/Wrl1L9erVU2xXuHBh8+Po6Gjza7q4uJjXx8bGmtcrpShY0FTMMyEhgYSEBPNz94+ltSYmJibFsdzc3Ni3b1+G5VCyuzx/6enff6MZOHANrVot5dSp6wQG/mnrkISwOoPBwLZt2+jatavF+8QnJHD+/Hnc3NwAU5mOn376iYMHDxIcHMzrr79unrHtzJkzBAQEcPz4cQoUKMDUqVPZunUrBw8epG7dugQGBgIwYsQIQkJCOHbsGDExMaxfv/6h112+fLn5clDyv549ez60bVpluVMTFBSEh4cHb775JrNnzzav37t3LzVq1MDHx4cFCxbg4OBgPmd+fn6UKlWKtm3b0qBBA/M+L730EmXKlOHUqVOMHDnSvL5u3brs3LnT0lOcbeXZFoXRqPnyy4OMH7+VW7dicXKy5913mzFuXCNbhybygEf55Z+ZYmJi8PPzIyIiAi8vL9q2bWvxvtdv3UpRKE9rzdtvv82OHTuws7MjIiLCPI9CxYoVzRP07NmzhxMnTpjrNcXHx9OwYUPAVK9oxowZ3Lt3j5s3b1KjRg2efvrpFK/br18/+vXr90TvOzXDhw9n+PDhfPvtt0ydOtVclK9BgwYcP36ckydPMnDgQDp27GiujBsaGkpkZCTPPPMMx44dMxflW7x4MQaDgZEjR7Jy5UpeeuklwFQK/NSpU5kee1bLky2KCxdu0bTpYgYPXs+tW7G0a+fBsWMBvPtuM5yc8mzuFHlA/vz5CQ0N5dKlS2itCQoKsnxfJ6cUpb6XL1/OtWvXOHDgAKGhoZQuXdr8/P0y4GBKKG3btjVXZT1x4gRffvklsbGxBAQEsHr1ao4ePcqrr76a4vjJX8fSFkV6ZbnT0qdPH9asWfPQei8vLwoWLMixpDpX9xUtWpSWLVuapzG9z97enj59+vDDDz+Y12VlKXBrypOJonBhJ8LCblCmTEFWrHiWzZv7UblycVuHJUSWcXFxYfbs2cycOTPN+SUeVKxIEQwGg/nLPCoqilKlSuHo6EhwcDCXLl1KdT9/f392795tLiEeHR1NWFiY+TglSpTg7t27ac6V0a9fv1TLgKe2fb169Thz5gwXLlwgPj6eFStWpHp57cyZM+bHGzZsoEqVKoBpHoz75+PSpUucOnUKNzc3rl27RmRkJGBqlW3ZsgVPT0+01ub3pbVm3bp1eHp6mo+dlaXArSnP/Hz+5ZeztGjhhpOTA66uLqxb14fq1UtSpIizrUMTwiZq1aqFr68v3333Hf3797don3bt2rFr1y7atGlDv379ePrpp/Hx8aFu3bopviCTK1myJF9//TV9+/Y1zz43depUqlatyquvvoq3tzdlypShXr16T/yeHBwcmDt3Lu3bt8dgMPDyyy9To0YNACZOnEjdunXp2rUrc+fOZevWrTg6OlKsWDHzZaddu3Yxbdo0HB0dsbOzY968eZQoUYIjR44wcOBADAYDRqOR5557ji5dumA0Ghk4cCC3b99Ga03NmjWZP3++OZ7du3enOmFSTpPry4xfvhzFqFGbWbPmFB980JJ3321mxehEuqTMeI4vM34yPp5PP/2UZcuW2Tii7O/QoUMEBgba5FxJmXELJSYamT17LxMnBhMdnUDBgvkoXjznXysUwpZq165Ny5YtMRgMMmdEBq5fv84HH3xg6zAyRa5MFHv2hDN06HoOHzaNwHj2WS9mzepAuXKFM9hTCJGRl19+2dYh5AiPMqIsu8t1iWLv3nAaNfoSrcHNrShz53akc+eqtg5LCMDU4SkzHwprskZ3Qq5LFPXrl6N9+8rUqlWGd99thouLo61DEgIw3aB248YNXF1dJVkIq9Bac+PGDZydM3eQTo5PFGfO3GDMmF8IDGxP1aqmf4AbNjyPnZ38QxTZS/ny5QkPD+fatWu2DuWRJSTdSOco/RLZnrOzM+XLZ+5sm1ZNFEqpDsAswB74Qms97YHnnYClQB3gBtBba33RkmPHxSUybdouPvpoF3FxBpydHVi9+jkASRIiW3J0dMTd3d3WYTyWk8/0AGx3R7mwLaslCqWUPRAEtAXCgRCl1Dqt9Ylkmw0CbmmtKyul+gDTgd4ZHXvbtvMEBGwkLOwGAC+95MeMGbmn40gIIbITa7Yo6gNntdbnAZRSK4BuQPJE0Q2YnPR4NTBXKaV0Br0xbdqYxiV7eZVgwYL/qr0KIYTIfNZMFOWAy8mWw4EGaW2jtU5USkUBrsD1tA7qcQVWVVthWjACg+cijeGc4n+m/6zImTedCZFX5YjObKXUYGBw0mJc9dOnjqW3fR5SgnSSah4j5+I/1jsXOW+0lnwu/lPtcXe0ZqKIAJ5Ktlw+aV1q24QrpRyAIpg6tVPQWi8EFgIopfY/7m3ouY2ci//IufiPnIv/yLn4j1Jq/+Pua83qsSFAFaWUu1IqH9AHWPfANuuAgUmPewK/ZdQ/IYQQImtZrUWR1OcwAvgF0/DYr7TWx5VSUzDN3boO+BJYppQ6C9zElEyEEEJkI1bto9BabwQ2PrBuYrLHsUCvRzzswkwILbeQc/EfORf/kXPxHzkX/3nsc5HjyowLIYTIWnlyhjshhBCWy7aJQinVQSl1Wil1Vik1IZXnnZRSK5Oe36uUcsv6KLOGBedirFLqhFLqiFJqm1Iq196BmNG5SLbds0oprZTKtSNeLDkXSqnnkj4bx5VS32Z1jFnFgn8jFZRSwUqpQ0n/TjrZIk5rU0p9pZT6VymV6i0EymR20nk6opSqbdGBtdbZ7g9T5/c5oBKQDzgMVH9gmwBgQdLjPsBKW8dtw3PREnBJejwsL5+LpO0KATuAPUBdW8dtw89FFeAQUCxpuZSt47bhuVgIDEt6XB24aOu4rXQumgG1gWNpPN8J2AQowB/Ya8lxs2uLwlz+Q2sdD9wv/9JwofEAAAYpSURBVJFcN2BJ0uPVQGuVO2s3Z3gutNbBWut7SYt7MN2zkhtZ8rkA+ABT3bDYrAwui1lyLl4FgrTWtwC01v9mcYxZxZJzoYH7M5cVAf7OwviyjNZ6B6YRpGnpBizVJnuAokqpshkdN7smitTKf5RLaxutdSJwv/xHbmPJuUhuEKZfDLlRhuciqSn9lNZ6Q1YGZgOWfC6qAlWVUruVUnuSqjnnRpaci8nAC0qpcEwjMUdmTWjZzqN+nwA5pISHsIxS6gWgLtDc1rHYglLKDggEXrRxKNmFA6bLTy0wtTJ3KKV8tNaRNo3KNvoCX2utZyqlGmK6f8tba220dWA5QXZtUTxK+Q/SK/+RC1hyLlBKtQHeAbpqreOyKLasltG5KAR4A9uVUhcxXYNdl0s7tC35XIQD67TWCVrrC0AYpsSR21hyLgYB3/9/e/cWYlUVx3H8+yM0LUEwKZKgKYwsSaeykHwIs6QLCYU4iGkGUUYRWvYQGhX0EFgPmdjYBVTwAlZWiFQSdpMptfASZhkmEkj5IBI2vUz/HtYaPU1n9tlnNDsz5/eBA3PW3muvdRbM/p+19uG/ACKiAxhCygPVbErdT3pq1EDh9B+n1BwLSdcCK0hBYqCuQ0ONsYiI4xExMiJaIqKF9LxmWkT0OcdNAyvzP/IeaTaBpJGkpaiDZ7OTZ0mZsTgMTAGQdBUpUPS/rQZP3wfAnPzrp4nA8Yg4UqtSQy49hdN/nFRyLJYAw4AN+Xn+4YiY9r91+j9SciyaQsmx+AiYKmkf0AU8FREDbtZdciyeBN6QtID0YHvuQPxiKWkd6cvByPw85llgEEBEtJOez9wJ/AT8ATxQ6roDcKzMzOwMatSlJzMzaxAOFGZmVsiBwszMCjlQmJlZIQcKMzMr5EBhDUdSl6RdFa+WgnNbesuUWWebn+bso7tzyou6N6KXNE/SnPz3XEmjKo69KenqM9zPHZJaS9SZL+m8023bmpcDhTWizohorXgdOkvtzoqI8aRkk0vqrRwR7RGxOr+dC4yqOPZgROw7I7081c/llOvnfMCBwvrMgcL6hTxz+ELSt/l1U5VzxkranmcheyRdkcvvqyhfIemcGs19DozOdafkPQz25lz/5+byF3VqD5CXctlzkhZKmk7KubUmtzk0zwQm5FnHyZt7nnks62M/O6hI6CbpNUk7lfaeeD6XPU4KWFslbc1lUyV15HHcIGlYjXasyTlQWCMaWrHstDGX/QbcFhHXAW3A0ir15gGvREQr6Ub9S07X0AZMyuVdwKwa7d8N7JU0BFgJtEXENaRMBo9IugC4BxgbEeOAFyorR8TbwE7SN//WiOisOPxOrtutDVjfx37eTkrT0W1RREwAxgE3SxoXEUtJKbUnR8TknMpjMXBrHsudwBM12rEm15ApPKzpdeabZaVBwLK8Jt9FylvUUwewSNIlwLsRcUDSFOB6YEdObzKUFHSqWSOpEzhESkN9JfBzRPyYj68CHgWWkfa6eEvSJmBT2Q8WEUclHcx5dg4AY4Bt+br19HMwKW1L5TjNkPQQ6f/6YtIGPXt61J2Yy7fldgaTxs2sVw4U1l8sAH4FxpNmwv/alCgi1kr6GrgL2CzpYdJOXqsi4ukSbcyqTCAoaUS1k3JuoRtJSeamA48Bt9TxWdYDM4D9wMaICKW7dul+At+Qnk+8Ctwr6TJgIXBDRByTtJKU+K4nAVsiYmYd/bUm56Un6y+GA0fy/gGzScnf/kHS5cDBvNzyPmkJ5hNguqQL8zkjVH5P8R+AFkmj8/vZwGd5TX94RGwmBbDxVer+Tkp7Xs1G0k5jM0lBg3r7mRPaPQNMlDSGtHvbCeC4pIuAO3rpy1fApO7PJOl8SdVmZ2YnOVBYf7EcuF/SbtJyzYkq58wAvpO0i7Qvxer8S6PFwMeS9gBbSMsyNUXEn6Tsmhsk7QX+AtpJN91N+XpfUn2NfyXQ3v0wu8d1jwHfA5dGxPZcVnc/87OPl0lZYXeT9sfeD6wlLWd1ex34UNLWiDhK+kXWutxOB2k8zXrl7LFmZlbIMwozMyvkQGFmZoUcKMzMrJADhZmZFXKgMDOzQg4UZmZWyIHCzMwKOVCYmVmhvwHfDDZkx5E6VgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "DTCR_WF.AUC_Curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You might notice that given how small this dataset is, doing one training split does not give us a good assesment for how predictive the TCR signature may be. In this case, we would want to use a K-fold cross validation to train on 16 of the samples and test on 4 and iterate until we've covered the entire cohort. When calling the K-fold cross validation command, one can provide the number of folds or if none is provided, it assumes a leave-one-out strategy. Therefore, we will set the folds to 5 where each fold will contain 4 samples. Here, we will also utilize an option for training where we apply a hinge loss to the training data where the per-sample loss is only used to penalize the model if it is above a certain threshold. This prevents over-fitting of the neural network. The idea here is that once a sample has been called correctly, there is no additional benefit to get it 'more right'. This is a particularly good training strategy when we are working with small datasets such as this one. We will also set the combine_train_valid parameter to True to combine what was originally the train and validation sets into one training set while leaving the test set for assessing performance. Otherwise, this method normally applies an early stopping criterion on the validation set. Since we have combined our train and validation sets together, we need to apply a stopping criterion on this training data. We will set the minimum loss before stopping training on the training data to 0.1. This means that when the average training loss hits 0.1, the neural network will stop training.\n",
    "\n",
    "Here, we will also introduce other hyper-parameters we can modify including changing the size of the network. The size of the network parameter chooses the number of nodes for the 3 convolutional layers. Here, we will switch the sie of the network to 'small' which use 12,32,64 nodes respectively for the 3 conv layers. We will also leave out 4 samples for testing while we use 16 for training. Finally, we will also train our model with 64 concepts, a hyper-parameter of the multiple-instance learning (MIL) algorithm that we can change depending on the level of heterogeneity we expect in our data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "folds = 5\n",
    "size_of_net = 'small'\n",
    "num_concepts=64\n",
    "hinge_loss_t = 0.1\n",
    "train_loss_min=0.1\n",
    "DTCR_WF.K_Fold_CrossVal(combine_train_valid=True, hinge_loss_t = hinge_loss_t,train_loss_min = train_loss_min,folds=folds,\n",
    "                       num_concepts=num_concepts, size_of_net=size_of_net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then assess the performance once again through plotting the ROC curves."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "DTCR_WF.AUC_Curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also train our model in a Monte-Carlo fashion where we perform N number of monte-carlo simulation, randomly sampling train/test sets to train our model and assess predictive signature in our data in a more granular way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture\n",
    "folds = 25\n",
    "LOO = 4\n",
    "epochs_min = 10\n",
    "size_of_net = 'small'\n",
    "num_concepts=64\n",
    "hinge_loss_t = 0.1\n",
    "train_loss_min=0.1\n",
    "\n",
    "DTCR_WF.Monte_Carlo_CrossVal(folds=folds,LOO=LOO,epochs_min=epochs_min,num_concepts=num_concepts,size_of_net=size_of_net,\n",
    "                             train_loss_min=train_loss_min,hinge_loss_t=hinge_loss_t,combine_train_valid=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once again, we can look at the performance via a ROC curve."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "DTCR_WF.AUC_Curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once our algorithm has been trained, we may want to see which sequences are the most strongly predicted for each label. To do this we will run the following command. The output of the command is a dictionary of dataframes within the object we can view. Additionally, these dataframes can be found in the results folder underneath the subdirectory 'Rep_Sequences'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "DTCR_WF.Representative_Sequences()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      alpha            beta      v_beta      d_beta      j_beta v_alpha  \\\n",
      "12045  None   CASSLPASYEQYF  TCRBV12-01  unresolved  TCRBJ02-07    None   \n",
      "11735  None    CASGAWGYEQYF  TCRBV13-02  unresolved  TCRBJ02-07    None   \n",
      "11736  None  CASGLQMGQYEQYF  TCRBV13-02  TCBDD01-01  TCRBJ02-07    None   \n",
      "12110  None   CASSDGESDTQYF  TCRBV13-01  TCBDD01-01  TCRBJ02-05    None   \n",
      "12091  None   CASSLGSYAEQFF  TCRBV14-01  unresolved  TCRBJ02-01    None   \n",
      "13044  None    CASGAWGYEQYF  TCRBV13-02  unresolved  TCRBJ02-07    None   \n",
      "15210  None   CASSLGGRDEQYF  TCRBV03-01  TCBDD02-01  TCRBJ02-07    None   \n",
      "14089  None    FASGAWGYEQYF  TCRBV13-02  unresolved  TCRBJ02-07    None   \n",
      "15795  None    CASGAWGYEQYF  TCRBV13-02  unresolved  TCRBJ02-07    None   \n",
      "17055  None   CASSLGLYAEQFF  TCRBV13-01  unresolved  TCRBJ02-01    None   \n",
      "\n",
      "      j_alpha    Class         Sample      Freq  Counts           HLA  \\\n",
      "12045    None  Control  CONTROL-3.tsv  0.001773       2  [N, o, n, e]   \n",
      "11735    None  Control  CONTROL-3.tsv  0.140957     159  [N, o, n, e]   \n",
      "11736    None  Control  CONTROL-3.tsv  0.039007      44  [N, o, n, e]   \n",
      "12110    None  Control  CONTROL-3.tsv  0.000887       1  [N, o, n, e]   \n",
      "12091    None  Control  CONTROL-3.tsv  0.000887       1  [N, o, n, e]   \n",
      "13044    None  Control  CONTROL-5.tsv  0.172929     879  [N, o, n, e]   \n",
      "15210    None  Control  CONTROL-5.tsv  0.000197       1  [N, o, n, e]   \n",
      "14089    None  Control  CONTROL-5.tsv  0.000197       1  [N, o, n, e]   \n",
      "15795    None  Control  CONTROL-1.tsv  0.057541     132  [N, o, n, e]   \n",
      "17055    None  Control  CONTROL-1.tsv  0.000436       1  [N, o, n, e]   \n",
      "\n",
      "           9H10     Combo   Control        RT  \n",
      "12045  0.000296  0.000076  0.999429  0.000199  \n",
      "11735  0.000235  0.000082  0.999418  0.000265  \n",
      "11736  0.000297  0.000077  0.999293  0.000333  \n",
      "12110  0.000385  0.000071  0.999293  0.000251  \n",
      "12091  0.000637  0.000084  0.998865  0.000415  \n",
      "13044  0.000446  0.000196  0.998828  0.000530  \n",
      "15210  0.000696  0.000112  0.998781  0.000410  \n",
      "14089  0.000411  0.000181  0.998778  0.000629  \n",
      "15795  0.000666  0.000266  0.998745  0.000323  \n",
      "17055  0.000819  0.000211  0.998704  0.000266  \n"
     ]
    }
   ],
   "source": [
    "print(DTCR_WF.Rep_Seq['Control'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, we may want to know which learned motifs are associated with a given label. To do this, we can run the following command with the label we want to know the predictive motifs for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Motif Identification Completed\n"
     ]
    }
   ],
   "source": [
    "DTCR_WF.Motif_Identification('Control')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The motifs can then be found in fasta files in the results folder underneath (label)(alpha/beta)Motifs. These fasta fiels can then be used with \"https://weblogo.berkeley.edu/logo.cgi\" for motif visualization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
